home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / utils / adt / int.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-27  |  6.6 KB  |  341 lines
  1. /*
  2.  * int.c --
  3.  *     Functions for the built-in integer types.
  4.  *
  5.  *    I/O routines:
  6.  *     int2in, int2out, int28in, int28out, int4in, int4out
  7.  *    Conversion routines:
  8.  *     itoi
  9.  *    Boolean operators:
  10.  *     inteq, intne, intlt, intle, intgt, intge
  11.  *    Arithmetic operators:
  12.  *     intpl, intmi, int4mul, intdiv
  13.  *
  14.  *    Arithmetic operators:
  15.  *     intmod, int4fac
  16.  */
  17.  
  18. #include "tmp/postgres.h"
  19. #include "utils/fmgr.h"
  20. #include "utils/log.h"
  21.  
  22. RcsId("$Header: /private/postgres/src/utils/adt/RCS/int.c,v 1.13 1992/07/28 19:11:44 mao Exp $");
  23.  
  24.  
  25.         /* ========== USER I/O ROUTINES ========== */
  26.  
  27.  
  28. /*
  29.  *    int2in        - converts "num" to short
  30.  */
  31. int32
  32. int2in(num)
  33.     char    *num;
  34. {
  35.     extern int    atoi();
  36.  
  37.     return((int32) atoi(num));
  38. }
  39.  
  40. /*
  41.  *    int2out        - converts short to "num"
  42.  */
  43. char *
  44. int2out(sh)
  45.     int16    sh;
  46. {
  47.     char        *result;
  48.     extern int    itoa();
  49.  
  50.     result = (char *)palloc(7);    /* assumes sign, 5 digits, '\0' */
  51.     itoa((int) sh, result);
  52.     return(result);
  53. }
  54.  
  55. /*
  56.  *    int28in        - converts "num num ..." to internal form
  57.  *
  58.  *    Note:
  59.  *        Fills any nonexistent digits with NULLs.
  60.  */
  61. int16 *
  62. int28in(shs)
  63.     char    *shs;
  64. {
  65.     register int16    (*result)[];
  66.     int        nums;
  67.  
  68.     if (shs == NULL)
  69.         return(NULL);
  70.     result = (int16 (*)[]) palloc(sizeof(int16 [8]));
  71.     if ((nums = sscanf(shs, "%hd%hd%hd%hd%hd%hd%hd%hd",
  72.                *result,
  73.                *result + 1,
  74.                *result + 2,
  75.                *result + 3,
  76.                *result + 4,
  77.                *result + 5,
  78.                *result + 6,
  79.                *result + 7)) != 8) {
  80.         do
  81.             (*result)[nums++] = 0;
  82.         while (nums < 8);
  83.     }
  84.     return((int16 *) result);
  85. }
  86.  
  87. /*
  88.  *    int28out    - converts internal form to "num num ..."
  89.  */
  90. char *
  91. int28out(shs)
  92.     int16    (*shs)[];
  93. {
  94.     register int    num;
  95.     register int16    *sp;
  96.     register char    *rp;
  97.     char         *result;
  98.     extern int    itoa();
  99.  
  100.     if (shs == NULL) {
  101.         result = (char *)palloc(2);
  102.         result[0] = '-';
  103.         result[1] = '\0';
  104.         return(result);
  105.     }
  106.     rp = result = (char *)palloc(8 * 7); /* assumes sign, 5 digits, ' ' */
  107.     sp = *shs;
  108.     for (num = 8; num != 0; num--) {
  109.         itoa(*sp++, rp);
  110.         while (*++rp != '\0')
  111.             ;
  112.         *rp++ = ' ';
  113.     }
  114.     *--rp = '\0';
  115.     return(result);
  116. }
  117.  
  118. /*
  119.  *    int28in        - converts "num num ..." to internal form
  120.  *
  121.  *    Note:
  122.  *        Fills any nonexistent digits with NULLs.
  123.  */
  124. int32 *
  125. int44in(input_string)
  126.     char    *input_string;
  127.  
  128. {
  129.     int32 *foo = (int32 *)palloc(4*sizeof(int32));
  130.     register int i = 0;
  131.  
  132.     i = sscanf(input_string,
  133.            "%ld, %ld, %ld, %ld",
  134.            &foo[0],
  135.            &foo[1],
  136.            &foo[2],
  137.            &foo[3]);
  138.     while (i < 4)
  139.     foo[i++] = 0;
  140.  
  141.     return(foo);
  142. }
  143.  
  144. /*
  145.  *    int28out    - converts internal form to "num num ..."
  146.  */
  147. char *
  148. int44out(an_array)
  149.     int32    an_array[];
  150. {
  151.     int temp = 4;
  152.     char *output_string = NULL;
  153.     extern int itoa();
  154.     int i;
  155.  
  156.     if ( temp > 0 ) {
  157.     char *walk;
  158.     output_string = (char *)palloc(16*temp); /* assume 15 digits + sign */
  159.     walk = output_string;
  160.     for ( i = 0 ; i < temp ; i++ ) {
  161.         itoa(an_array[i],walk);
  162.         while (*++walk != '\0')
  163.           ;
  164.         *walk++ = ' ';
  165.     }
  166.     *--walk = '\0';
  167.     }
  168.     return(output_string);
  169. }
  170.  
  171.  
  172.          /* ========== PUBLIC ROUTINES ========== */
  173.  
  174.  
  175. /*
  176.  *    int4in        - converts "num" to int4
  177.  */
  178. int32
  179. int4in(num)
  180.     char    *num;
  181. {
  182.     extern long    atol();
  183.  
  184.     return((int32) atol(num));
  185. }
  186.  
  187. /*
  188.  *    int4out        - converts int4 to "num"
  189.  */
  190. char *
  191. int4out(l)
  192.     int32    l;
  193. {
  194.     char        *result;
  195.     extern int    ltoa();
  196.  
  197.     result = (char *)palloc(12);    /* assumes sign, 10 digits, '\0' */
  198.     ltoa((long) l, result);
  199.     return(result);
  200. }
  201.  
  202.  
  203. /*
  204.  *    ===================
  205.  *    CONVERSION ROUTINES
  206.  *    ===================
  207.  */
  208.  
  209. /*
  210.  *    itoi - "convert" arg1 to another integer type
  211.  */
  212. int32
  213. itoi(arg1)
  214.     int32    arg1;
  215. {
  216.     return(arg1);
  217. }
  218.  
  219.  
  220. /*
  221.  *    =========================
  222.  *    BOOLEAN OPERATOR ROUTINES
  223.  *    =========================
  224.  *
  225.  *    These operations are used (and work correctly) for nearly
  226.  *    every integer type, e.g., int2, int32, bool, char, OID, ...
  227.  */
  228.  
  229. /*
  230.  *    inteq        - returns 1 iff arg1 == arg2
  231.  *    intne        - returns 1 iff arg1 != arg2
  232.  *    intlt        - returns 1 iff arg1 < arg2
  233.  *    intle        - returns 1 iff arg1 <= arg2
  234.  *    intgt        - returns 1 iff arg1 > arg2
  235.  *    intge        - returns 1 iff arg1 >= arg2
  236.  */
  237. int32 int4eq(arg1, arg2)    int32    arg1, arg2; { return(arg1 == arg2); }
  238. int32 int4ne(arg1, arg2)     int32    arg1, arg2; { return(arg1 != arg2); }
  239. int32 int4lt(arg1, arg2)     int32    arg1, arg2; { return(arg1 < arg2); }
  240. int32 int4le(arg1, arg2)     int32    arg1, arg2; { return(arg1 <= arg2); }
  241. int32 int4gt(arg1, arg2)    int32    arg1, arg2; { return(arg1 > arg2); } 
  242. int32 int4ge(arg1, arg2)    int32    arg1, arg2; { return(arg1 >= arg2); }
  243.  
  244. int32 int2eq(arg1, arg2)    int16    arg1, arg2; { return(arg1 == arg2); }
  245. int32 int2ne(arg1, arg2)    int16    arg1, arg2; { return(arg1 != arg2); }
  246. int32 int2lt(arg1, arg2)    int16    arg1, arg2; { return(arg1 < arg2); }
  247. int32 int2le(arg1, arg2)    int16    arg1, arg2; { return(arg1 <= arg2); }
  248. int32 int2gt(arg1, arg2)    int16    arg1, arg2; { return(arg1 > arg2); } 
  249. int32 int2ge(arg1, arg2)    int16    arg1, arg2; { return(arg1 >= arg2); }
  250.  
  251. int32 keyfirsteq(arg1, arg2)    int16    *arg1,arg2; { return(*arg1 == arg2); }
  252.  
  253. /*
  254.  *    int[24]pl    - returns arg1 + arg2
  255.  *    int[24]mi    - returns arg1 - arg2
  256.  *    int[24]mul    - returns arg1 * arg2
  257.  *    int[24]div    - returns arg1 / arg2
  258.  */
  259. int32 int4um(arg)        int32    arg; { return(-arg); }
  260. int32 int4pl(arg1, arg2)     int32    arg1, arg2; { return(arg1 + arg2); }
  261. int32 int4mi(arg1, arg2)    int32    arg1, arg2; { return(arg1 - arg2); }
  262. int32 int4mul(arg1, arg2)    int32    arg1, arg2; { return(arg1 * arg2); }
  263. int32 int4div(arg1, arg2)    int32    arg1, arg2; { return(arg1 / arg2); }
  264. int32 int4inc(arg)        int32   arg;        { return(arg + (int32)1); }
  265.  
  266. int16 int2um(arg)        int16    arg; { return(-arg); }
  267. int16 int2pl(arg1, arg2)    int16    arg1, arg2; { return(arg1 + arg2); }
  268. int16 int2mi(arg1, arg2)    int16    arg1, arg2; { return(arg1 - arg2); }
  269. int16 int2mul(arg1, arg2)    int16    arg1, arg2; { return(arg1 * arg2); }
  270. int16 int2div(arg1, arg2)    int16    arg1, arg2; { return(arg1 / arg2); }
  271. int16 int2inc(arg)        int16   arg;        { return(arg + (int16)1); }
  272.  
  273. /*
  274.  *    int[24]mod    - returns arg1 mod arg2
  275.  */
  276. int32 int4mod(arg1, arg2)    int32    arg1, arg2; { return(arg1 % arg2); }
  277. int32 int2mod(arg1, arg2)    int16    arg1, arg2; { return(arg1 % arg2); }
  278.  
  279. /*
  280.  *    int[24]fac    - returns arg1!
  281.  */
  282. int32
  283. int4fac(arg1)
  284.     int32     arg1;
  285. {
  286.     int32    result;
  287.  
  288.     if (arg1 < 1)
  289.         result = 0;
  290.     else 
  291.         for (result = 1; arg1 > 0; --arg1)
  292.             result *= arg1;
  293.     return(result);
  294. }
  295.  
  296. int32
  297. int2fac(arg1)
  298.     int16     arg1;
  299. {
  300.     int16    result;
  301.  
  302.     if (arg1 < 1)
  303.         result = 0;
  304.     else 
  305.         for (result = 1; arg1 > 0; --arg1)
  306.             result *= arg1;
  307.     return(result);
  308. }
  309.  
  310. int16
  311. int2larger(arg1, arg2)
  312.     int16    arg1;
  313.     int16    arg2;
  314. {
  315.     return ((arg1 > arg2) ? arg1 : arg2);
  316. }
  317.  
  318. int16
  319. int2smaller(arg1, arg2)
  320.     int16    arg1;
  321.     int16    arg2;
  322. {
  323.     return ((arg1 > arg2) ? arg2 : arg1);
  324. }
  325.  
  326. int32
  327. int4larger(arg1, arg2)
  328.     int32    arg1;
  329.     int32    arg2;
  330. {
  331.     return ((arg1 > arg2) ? arg1 : arg2);
  332. }
  333.  
  334. int32
  335. int4smaller(arg1, arg2)
  336.     int32    arg1;
  337.     int32    arg2;
  338. {
  339.     return ((arg1 > arg2) ? arg2 : arg1);
  340. }
  341.